home *** CD-ROM | disk | FTP | other *** search
# Source Generated with Decompyle++ # File: in.pyc (Python 2.6) __all__ = ('BusConnection',) __docformat__ = 'reStructuredText' import logging import weakref from _dbus_bindings import validate_interface_name, validate_member_name, validate_bus_name, validate_object_path, validate_error_name, BUS_SESSION, BUS_STARTER, BUS_SYSTEM, DBUS_START_REPLY_SUCCESS, DBUS_START_REPLY_ALREADY_RUNNING, BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, NAME_FLAG_ALLOW_REPLACEMENT, NAME_FLAG_DO_NOT_QUEUE, NAME_FLAG_REPLACE_EXISTING, RELEASE_NAME_REPLY_NON_EXISTENT, RELEASE_NAME_REPLY_NOT_OWNER, RELEASE_NAME_REPLY_RELEASED, REQUEST_NAME_REPLY_ALREADY_OWNER, REQUEST_NAME_REPLY_EXISTS, REQUEST_NAME_REPLY_IN_QUEUE, REQUEST_NAME_REPLY_PRIMARY_OWNER from dbus.connection import Connection from dbus.exceptions import DBusException from dbus.lowlevel import HANDLER_RESULT_NOT_YET_HANDLED _NAME_OWNER_CHANGE_MATCH = "type='signal',sender='%s',interface='%s',member='NameOwnerChanged',path='%s',arg0='%%s'" % (BUS_DAEMON_NAME, BUS_DAEMON_IFACE, BUS_DAEMON_PATH) _NAME_HAS_NO_OWNER = 'org.freedesktop.DBus.Error.NameHasNoOwner' _logger = logging.getLogger('dbus.bus') class NameOwnerWatch(object): __slots__ = ('_match', '_pending_call') def __init__(self, bus_conn, bus_name, callback): validate_bus_name(bus_name) def signal_cb(owned, old_owner, new_owner): callback(new_owner) def error_cb(e): if e.get_dbus_name() == _NAME_HAS_NO_OWNER: callback('') else: logging.basicConfig() _logger.debug('GetNameOwner(%s) failed:', bus_name, exc_info = (e.__class__, e, None)) self._match = bus_conn.add_signal_receiver(signal_cb, 'NameOwnerChanged', BUS_DAEMON_IFACE, BUS_DAEMON_NAME, BUS_DAEMON_PATH, arg0 = bus_name) self._pending_call = bus_conn.call_async(BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, 'GetNameOwner', 's', (bus_name,), callback, error_cb, utf8_strings = True) def cancel(self): if self._match is not None: self._match.remove() if self._pending_call is not None: self._pending_call.cancel() self._match = None self._pending_call = None class BusConnection(Connection): '''A connection to a D-Bus daemon that implements the ``org.freedesktop.DBus`` pseudo-service. :Since: 0.81.0 ''' TYPE_SESSION = BUS_SESSION TYPE_SYSTEM = BUS_SYSTEM TYPE_STARTER = BUS_STARTER START_REPLY_SUCCESS = DBUS_START_REPLY_SUCCESS START_REPLY_ALREADY_RUNNING = DBUS_START_REPLY_ALREADY_RUNNING def __new__(cls, address_or_type = TYPE_SESSION, mainloop = None): bus = cls._new_for_bus(address_or_type, mainloop = mainloop) bus._bus_names = weakref.WeakValueDictionary() bus._signal_sender_matches = { } return bus def add_signal_receiver(self, handler_function, signal_name = None, dbus_interface = None, bus_name = None, path = None, **keywords): named_service = keywords.pop('named_service', None) if named_service is not None: if bus_name is not None: raise TypeError('bus_name and named_service cannot both be specified') bus_name is not None bus_name = named_service warn = warn import warnings warn('Passing the named_service parameter to add_signal_receiver by name is deprecated: please use positional parameters', DeprecationWarning, stacklevel = 2) match = super(BusConnection, self).add_signal_receiver(handler_function, signal_name, dbus_interface, bus_name, path, **keywords) if bus_name is not None and bus_name != BUS_DAEMON_NAME: if bus_name[:1] == ':': def callback(new_owner): if new_owner == '': match.remove() else: callback = match.set_sender_name_owner watch = self.watch_name_owner(bus_name, callback) self._signal_sender_matches[match] = watch self.add_match_string(str(match)) return match def _clean_up_signal_match(self, match): self.remove_match_string_non_blocking(str(match)) watch = self._signal_sender_matches.pop(match, None) if watch is not None: watch.cancel() def activate_name_owner(self, bus_name): if bus_name is not None and bus_name[:1] != ':' and bus_name != BUS_DAEMON_NAME: try: return self.get_name_owner(bus_name) except DBusException: e = None if e.get_dbus_name() != _NAME_HAS_NO_OWNER: raise e.get_dbus_name() != _NAME_HAS_NO_OWNER self.start_service_by_name(bus_name) return self.get_name_owner(bus_name) None<EXCEPTION MATCH>DBusException return bus_name def get_object(self, bus_name, object_path, introspect = True, follow_name_owner_changes = False, **kwargs): '''Return a local proxy for the given remote object. Method calls on the proxy are translated into method calls on the remote object. :Parameters: `bus_name` : str A bus name (either the unique name or a well-known name) of the application owning the object. The keyword argument named_service is a deprecated alias for this. `object_path` : str The object path of the desired object `introspect` : bool If true (default), attempt to introspect the remote object to find out supported methods and their signatures `follow_name_owner_changes` : bool If the object path is a well-known name and this parameter is false (default), resolve the well-known name to the unique name of its current owner and bind to that instead; if the ownership of the well-known name changes in future, keep communicating with the original owner. This is necessary if the D-Bus API used is stateful. If the object path is a well-known name and this parameter is true, whenever the well-known name changes ownership in future, bind to the new owner, if any. If the given object path is a unique name, this parameter has no effect. :Returns: a `dbus.proxies.ProxyObject` :Raises `DBusException`: if resolving the well-known name to a unique name fails ''' if follow_name_owner_changes: self._require_main_loop() named_service = kwargs.pop('named_service', None) if named_service is not None: if bus_name is not None: raise TypeError('bus_name and named_service cannot both be specified') bus_name is not None warn = warn import warnings warn('Passing the named_service parameter to get_object by name is deprecated: please use positional parameters', DeprecationWarning, stacklevel = 2) bus_name = named_service if kwargs: raise TypeError('get_object does not take these keyword arguments: %s' % ', '.join(kwargs.iterkeys())) kwargs return self.ProxyObjectClass(self, bus_name, object_path, introspect = introspect, follow_name_owner_changes = follow_name_owner_changes) def get_unix_user(self, bus_name): '''Get the numeric uid of the process owning the given bus name. :Parameters: `bus_name` : str A bus name, either unique or well-known :Returns: a `dbus.UInt32` :Since: 0.80.0 ''' validate_bus_name(bus_name) return self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, 'GetConnectionUnixUser', 's', (bus_name,)) def start_service_by_name(self, bus_name, flags = 0): '''Start a service which will implement the given bus name on this Bus. :Parameters: `bus_name` : str The well-known bus name to be activated. `flags` : dbus.UInt32 Flags to pass to StartServiceByName (currently none are defined) :Returns: A tuple of 2 elements. The first is always True, the second is either START_REPLY_SUCCESS or START_REPLY_ALREADY_RUNNING. :Raises `DBusException`: if the service could not be started. :Since: 0.80.0 ''' validate_bus_name(bus_name) return (True, self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, 'StartServiceByName', 'su', (bus_name, flags))) def request_name(self, name, flags = 0): '''Request a bus name. :Parameters: `name` : str The well-known name to be requested `flags` : dbus.UInt32 A bitwise-OR of 0 or more of the flags `NAME_FLAG_ALLOW_REPLACEMENT`, `NAME_FLAG_REPLACE_EXISTING` and `NAME_FLAG_DO_NOT_QUEUE` :Returns: `REQUEST_NAME_REPLY_PRIMARY_OWNER`, `REQUEST_NAME_REPLY_IN_QUEUE`, `REQUEST_NAME_REPLY_EXISTS` or `REQUEST_NAME_REPLY_ALREADY_OWNER` :Raises `DBusException`: if the bus daemon cannot be contacted or returns an error. ''' validate_bus_name(name, allow_unique = False) return self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, 'RequestName', 'su', (name, flags)) def release_name(self, name): '''Release a bus name. :Parameters: `name` : str The well-known name to be released :Returns: `RELEASE_NAME_REPLY_RELEASED`, `RELEASE_NAME_REPLY_NON_EXISTENT` or `RELEASE_NAME_REPLY_NOT_OWNER` :Raises `DBusException`: if the bus daemon cannot be contacted or returns an error. ''' validate_bus_name(name, allow_unique = False) return self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, 'ReleaseName', 's', (name,)) def list_names(self): '''Return a list of all currently-owned names on the bus. :Returns: a dbus.Array of dbus.UTF8String :Since: 0.81.0 ''' return self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, 'ListNames', '', (), utf8_strings = True) def list_activatable_names(self): '''Return a list of all names that can be activated on the bus. :Returns: a dbus.Array of dbus.UTF8String :Since: 0.81.0 ''' return self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, 'ListNames', '', (), utf8_strings = True) def get_name_owner(self, bus_name): '''Return the unique connection name of the primary owner of the given name. :Raises `DBusException`: if the `bus_name` has no owner :Since: 0.81.0 ''' validate_bus_name(bus_name, allow_unique = False) return self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, 'GetNameOwner', 's', (bus_name,), utf8_strings = True) def watch_name_owner(self, bus_name, callback): '''Watch the unique connection name of the primary owner of the given name. `callback` will be called with one argument, which is either the unique connection name, or the empty string (meaning the name is not owned). :Since: 0.81.0 ''' return NameOwnerWatch(self, bus_name, callback) def name_has_owner(self, bus_name): '''Return True iff the given bus name has an owner on this bus. :Parameters: `bus_name` : str The bus name to look up :Returns: a `bool` ''' return bool(self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, 'NameHasOwner', 's', (bus_name,))) def add_match_string(self, rule): '''Arrange for this application to receive messages on the bus that match the given rule. This version will block. :Parameters: `rule` : str The match rule :Raises `DBusException`: on error. :Since: 0.80.0 ''' self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, 'AddMatch', 's', (rule,)) def add_match_string_non_blocking(self, rule): '''Arrange for this application to receive messages on the bus that match the given rule. This version will not block, but any errors will be ignored. :Parameters: `rule` : str The match rule :Raises `DBusException`: on error. :Since: 0.80.0 ''' self.call_async(BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, 'AddMatch', 's', (rule,), None, None) def remove_match_string(self, rule): '''Arrange for this application to receive messages on the bus that match the given rule. This version will block. :Parameters: `rule` : str The match rule :Raises `DBusException`: on error. :Since: 0.80.0 ''' self.call_blocking(BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, 'RemoveMatch', 's', (rule,)) def remove_match_string_non_blocking(self, rule): '''Arrange for this application to receive messages on the bus that match the given rule. This version will not block, but any errors will be ignored. :Parameters: `rule` : str The match rule :Raises `DBusException`: on error. :Since: 0.80.0 ''' self.call_async(BUS_DAEMON_NAME, BUS_DAEMON_PATH, BUS_DAEMON_IFACE, 'RemoveMatch', 's', (rule,), None, None) 
(.txt)